package interpreter

type RTResult struct {
	Value              interface{} // 值
	Error_             *Error // 错误
	FuncReturnValue    interface{} // 函数的返回值
	LoopShouldContinue bool        // 循环应该 continue
	LoopShouldBreak    bool        // 循环应该打断 break
}

// 实例化
func NewRTResult() *RTResult {
	temp := &RTResult{}
	return temp
}

// 设置值为初始值
func (r *RTResult) Reset() {
	r.Value = nil
	r.Error_ = nil
	r.FuncReturnValue = nil
	r.LoopShouldContinue = false
	r.LoopShouldBreak = false
}

// 注册
func (r *RTResult) Register(res *RTResult) interface{} {
	r.Error_ = res.Error_
	r.FuncReturnValue = res.FuncReturnValue
	r.LoopShouldContinue = res.LoopShouldContinue
	r.LoopShouldBreak = res.LoopShouldBreak
	return res.Value
}

// 成功
func (r *RTResult) Success(value interface{}) *RTResult {
	r.Reset()
	r.Value = value
	return r
}

// 成功 返回
func (r *RTResult) SuccessReturn(value interface{}) *RTResult {
	r.Reset()
	r.FuncReturnValue = value
	return r
}

// 成功 continue
func (r *RTResult) SuccessContinue(value interface{}) *RTResult {
	r.Reset()
	r.LoopShouldContinue = true
	return r
}

// 成功 break
func (r *RTResult) SuccessBreak(value interface{}) *RTResult {
	r.Reset()
	r.LoopShouldBreak = true
	return r
}

// fail失败
func (r *RTResult) Failure(err *Error) *RTResult {
	r.Reset()
	r.Error_ = err
	return r
}

// 应该返回的
func (r *RTResult) ShouldReturn() interface{} {
	// 这个将会允许你在当前的函数外面 continue ， break
	if r.Error_ != nil {
		return r.Error_
	}
	if r.FuncReturnValue != nil {
		return r.FuncReturnValue
	}
	if r.LoopShouldContinue {
		return r.LoopShouldContinue
	}
	if r.LoopShouldBreak {
		return r.LoopShouldBreak
	}
	return nil
}
